import { parse } from 'yaml'
const path = require('path');
const fs = require('fs');
const moment = require('moment')

// 获取项目运行环境
export const getEnv = () => {
  return process.env.RUNNING_ENV
}

// 读取项目配置
export const getConfig = () => {
  const environment = getEnv()
  const yamlPath = path.join(__dirname, `../.config/.${environment}.yaml`)
  const file = fs.readFileSync(yamlPath, 'utf8')
  const config = parse(file)
  return config
}

/**
 * @breif: 统一返回分页查询带参数的格式
 * @param {Object} ands
 * @param {number} pageNum
 * @param {number} pageSize
 * @return {*}
 */
export const formatAgragateCondition = (ands: Object[], pageNum: number, pageSize: number): string => {
  const condition = [
    {
      $match: {
        $and: ands
      }
    },
    {
      $facet: {
        total: [{ $count: 'count' }],
        rows: [{ $skip: (pageNum - 1) * pageSize }, { $limit: pageSize }, { $project: { __v: 0 } }]
      }
    },
    {
      $project: {
        rows: "$rows",
        total: { $arrayElemAt: ["$total.count", 0] },
      }
    }
  ]
  return JSON.stringify(condition)
}

/**
 * @breif: 日期时间格式化
 * @param {*} time
 * @param {*} partten
 * @return {*}
 */
export const formatDate = (time, partten = 'YYYY-MM-DD') => {
  return moment(time).format(partten)
}

/**
 * @breif: 文件硬删除(磁盘中也删除掉)
 * @param {*} path 要删除的文件路径
 * @param {*} fileType 文件类型，做校验使用,防止文件误删？也有可能用不到
 * @return {*}
 */
export const hardRemoveFile = (path, fileType): Promise<any> => {
  return new Promise((resolve, reject) => {
    try {
      fs.unlinkSync(path);
      resolve(true);
    } catch (error) {
      reject(error)
    }
  })
}

/**
 * @breif: 生成uuid
 * @param {*} string
 * @return {*}
 */
export const genUUID = (): string => {
  var temp_url = URL.createObjectURL(new Blob());
  var uuid = temp_url.toString(); // blob:https://xxx.com/b250d159-e1b6-4a87-9002-885d90033be3
  URL.revokeObjectURL(temp_url);
  return uuid.substr(uuid.lastIndexOf("/") + 1);
}

/**
 * 在web项目中创建页面
 * @param pagePath 页面路径（来源：用户输入）
 * pagePath可能的格式为：/home 、 /home/mine 、 /home/mine/123、/home/233
 * 需要创建对应的页面为： home.vue /home/mine.vue /home/mine/[id].vue  /home/[id].vue
 * @param modelType 模型类型（来源：用户选择的菜单类型）
 * @returns 返回包含状态和消息的对象，status为true表示成功，false表示失败，msg包含详细信息
 */
export const createWebPage = (pagePath: string, modelType: string, pageContent: string, detailCnontent?: string): { status: boolean; msg: string } => {
  try {
    // 获取项目根目录
    const projectRoot = path.resolve(__dirname, '../../');
    // 处理 pagePath，移除开头的 /
    const cleanPath = pagePath.startsWith('/') ? pagePath.slice(1) : pagePath;

    // 如果是list类型，创建文件夹和两个文件
    if (modelType === 'list') {
      // 分析路径结构，只支持单层路径，如 /news -> news文件夹
      const pathSegments = cleanPath.split('/');
      if (pathSegments.length !== 1) {
        console.error('list类型只支持单层路径格式，如 /news:', pagePath);
        return { status: false, msg: 'list类型只支持单层路径格式' };
      }

      const folderName = pathSegments[0] + "[...all]"; // 加上这个规则，为了匹配更多的路径，如 /news-xxx
      const targetDir = path.join(projectRoot, 'web', 'app', 'pages', folderName);
      const conflictFile = path.join(projectRoot, 'web', 'app', 'pages', `${folderName}.vue`);

      // 检查是否存在同名的.vue文件
      if (fs.existsSync(conflictFile)) {
        console.error(`创建失败：已存在同名文件 ${folderName}.vue，无法创建 ${folderName} 文件夹`);
        return { status: false, msg: `已存在同名文件 ${folderName}.vue，无法创建文件夹` };
      }

      // 检查文件夹是否已存在
      if (fs.existsSync(targetDir)) {
        console.log('文件夹已存在:', targetDir);
        return { status: false, msg: '文件夹已存在' };
      }

      // 创建文件夹
      fs.mkdirSync(targetDir, { recursive: true });
      console.log('list类型页面文件夹创建成功:', targetDir);

      // 创建 index.vue 文件
      const indexFilePath = path.join(targetDir, 'index.vue');
      fs.writeFileSync(indexFilePath, pageContent, 'utf8');
      console.log('- 创建文件:', indexFilePath);

      // 创建 [id].vue 文件
      const idFilePath = path.join(targetDir, '[id].vue');
      fs.writeFileSync(idFilePath, detailCnontent, 'utf8');
      console.log('- 创建文件:', idFilePath);

      return { status: true, msg: 'list类型页面文件系列创建成功' };
    }

    // page类型按照原有逻辑处理
    // 分析路径结构
    const pathSegments = cleanPath.split('/');
    let targetFilePath: string;

    if (pathSegments.length === 1) {
      // 格式：/home -> home.vue
      targetFilePath = path.join(projectRoot, 'web', 'app', 'pages', `${pathSegments[0]}[...all].vue`);
    } else {
      console.error('不支持的路径格式:', pagePath);
      return { status: false, msg: '不支持的路径格式' };
    }

    // 加入上面的else 前面
    //     else if (pathSegments.length === 2) {
    //   // 格式：/home/mine -> /home/mine.vue 或 /home/[id].vue
    //   const lastSegment = pathSegments[pathSegments.length - 1];

    //   // 判断最后一段是否为数字（动态路由）
    //   if (/^\d+$/.test(lastSegment)) {
    //     // 是数字，创建动态路由文件 /home/[id].vue
    //     const dirPath = path.join(projectRoot, 'web', 'app', 'pages', pathSegments[0]);
    //     targetFilePath = path.join(dirPath, '[id].vue');
    //   } else {
    //     // 不是数字，创建普通文件 /home/mine.vue
    //     const dirPath = path.join(projectRoot, 'web', 'app', 'pages', pathSegments[0]);
    //     targetFilePath = path.join(dirPath, `${lastSegment}.vue`);
    //   }
    // } else if (pathSegments.length === 3) {
    //   // 格式：/home/mine/123 -> /home/mine/[id].vue
    //   const lastSegment = pathSegments[pathSegments.length - 1];

    //   if (/^\d+$/.test(lastSegment)) {
    //     // 最后一段是数字，创建动态路由文件
    //     const dirPath = path.join(projectRoot, 'web', 'app', 'pages', pathSegments[0], pathSegments[1]);
    //     targetFilePath = path.join(dirPath, '[id].vue');
    //   } else {
    //     // 最后一段不是数字，创建普通文件
    //     const dirPath = path.join(projectRoot, 'web', 'app', 'pages', pathSegments[0], pathSegments[1]);
    //     targetFilePath = path.join(dirPath, `${lastSegment}.vue`);
    //   }
    // }

    // 检查文件是否已存在
    if (fs.existsSync(targetFilePath)) {
      console.log('文件已存在:', targetFilePath);
      return { status: false, msg: '页面文件已存在' };
    }

    // 确保目录存在
    const targetDir = path.dirname(targetFilePath);
    if (!fs.existsSync(targetDir)) {
      fs.mkdirSync(targetDir, { recursive: true });
    }

    // 创建文件
    fs.writeFileSync(targetFilePath, pageContent, 'utf8');

    console.log('页面创建成功:', targetFilePath);
    return { status: true, msg: '页面创建成功' };

  } catch (error) {
    console.error('创建页面失败:', error);
    return { status: false, msg: '创建页面失败: ' + error.message };
  }
}

/**
 * 删除Web页面文件或文件夹
 * @param pagePath 页面路径（来源：数据库中的菜单链接）
 * @param modelType 模型类型（来源：数据库中的菜单类型）
 * @returns 返回包含状态和消息的对象，status为true表示成功，false表示失败，msg包含详细信息
 */
export const deleteWebPage = (pagePath: string, modelType: string): { status: boolean; msg: string } => {
  try {
    // 获取项目根目录
    const projectRoot = path.resolve(__dirname, '../../');

    // 处理 pagePath，移除开头的 /
    const cleanPath = pagePath.startsWith('/') ? pagePath.slice(1) : pagePath;

    if (modelType === 'list') {
      // 对于 modelType 为 'list' 的情况，删除整个文件夹
      const pathSegments = cleanPath.split('/');
      if (pathSegments.length !== 1) {
        return { status: false, msg: 'list 类型只支持单层路径' };
      }

      const folderName = pathSegments[0] + '[...all]';
      const targetDirPath = path.join(projectRoot, 'web', 'app', 'pages', folderName);

      // 检查文件夹是否存在
      if (!fs.existsSync(targetDirPath)) {
        return { status: false, msg: `文件夹 ${folderName} 不存在` };
      }

      // 删除整个文件夹
      fs.rmSync(targetDirPath, { recursive: true, force: true });
      console.log('文件夹删除成功:', targetDirPath);
      return { status: true, msg: '列表页面文件夹删除成功' };

    } else if (modelType === 'page') {
      // 对于 modelType 为 'page' 的情况，删除对应的 .vue 文件
      const pathSegments = cleanPath.split('/')[0] + '[...all]';
      console.log(pathSegments,'pathSegments');
      
      let targetFilePath: string = path.join(projectRoot, 'web', 'app', 'pages', `${pathSegments}.vue`);

      // 检查文件是否存在
      if (!fs.existsSync(targetFilePath)) {
        return { status: false, msg: '页面文件不存在' };
      }

      // 删除文件
      fs.unlinkSync(targetFilePath);
      console.log('页面文件删除成功:', targetFilePath);

      // 检查父目录是否为空，如果为空则删除
      const parentDir = path.dirname(targetFilePath);
      const pagesDir = path.join(projectRoot, 'web', 'app', 'pages');
      if (parentDir !== pagesDir) {
        try {
          const files = fs.readdirSync(parentDir);
          if (files.length === 0) {
            fs.rmdirSync(parentDir);
            console.log('空目录删除成功:', parentDir);
          }
        } catch (error) {
          // 忽略删除空目录的错误
        }
      }

      return { status: true, msg: '页面文件删除成功' };

    } else {
      return { status: false, msg: '不支持的 modelType' };
    }

  } catch (error) {
    console.error('删除页面失败:', error);
    return { status: false, msg: '删除页面失败: ' + error.message };
  }
}



/**
 * 创建Web组件文件
 * @param content 组件内容
 * @param filename 文件名（不包含扩展名）
 * @returns 返回包含状态和消息的对象，status为true表示成功，false表示失败，msg包含详细信息
 */
export const createWebComponent = (content: string, filename: string, siteTemplate: string): { status: boolean; msg: string } => {
  try {
    // 获取项目根目录
    const projectRoot = path.resolve(__dirname, '../../');

    // 确保文件名不包含路径分隔符
    if (filename.includes('/') || filename.includes('\\')) {
      return { status: false, msg: '文件名不能包含路径分隔符' };
    }

    // 添加.vue扩展名（如果没有的话）
    const finalFilename = filename.endsWith('.vue') ? filename : `${filename}.vue`;

    // 构建目标文件路径
    const targetFilePath = path.join(projectRoot, 'web', 'app', 'templates', siteTemplate, finalFilename);

    // 检查文件是否已存在
    if (fs.existsSync(targetFilePath)) {
      console.log('组件文件已存在:', targetFilePath);
      return { status: false, msg: '组件文件已存在' };
    }

    // 确保目录存在
    const targetDir = path.dirname(targetFilePath);
    if (!fs.existsSync(targetDir)) {
      fs.mkdirSync(targetDir, { recursive: true });
    }

    // 创建文件
    fs.writeFileSync(targetFilePath, content, 'utf8');

    console.log('组件创建成功:', targetFilePath);
    return { status: true, msg: '组件创建成功' };

  } catch (error) {
    console.error('创建组件失败:', error);
    return { status: false, msg: '创建组件失败: ' + error.message };
  }
}

/**
 * 删除Web组件文件
 * @param filename 文件名（不包含扩展名）
 * @param siteTemplate 站点模板名称
 * @returns 返回包含状态和消息的对象，status为true表示成功，false表示失败，msg包含详细信息
 */
export const deleteWebComponent = (filename: string, siteTemplate: string): { status: boolean; msg: string } => {
  try {
    // 获取项目根目录
    const projectRoot = path.resolve(__dirname, '../../');

    // 确保文件名不包含路径分隔符
    if (filename.includes('/') || filename.includes('\\')) {
      return { status: false, msg: '文件名不能包含路径分隔符' };
    }

    // 添加.vue扩展名（如果没有的话）
    const finalFilename = filename.endsWith('.vue') ? filename : `${filename}.vue`;

    // 构建目标文件路径
    const targetFilePath = path.join(projectRoot, 'web', 'app', 'templates', siteTemplate, finalFilename);

    // 检查文件是否存在
    if (!fs.existsSync(targetFilePath)) {
      return { status: false, msg: '组件文件不存在' };
    }

    // 删除文件
    fs.unlinkSync(targetFilePath);
    console.log('组件文件删除成功:', targetFilePath);

    return { status: true, msg: '组件文件删除成功' };

  } catch (error) {
    console.error('删除组件失败:', error);
    return { status: false, msg: '删除组件失败: ' + error.message };
  }
}

/**
 * 更新Web组件文件内容
 * @param content 新的文件内容
 * @param filename 文件名（不包含扩展名）
 * @param siteTemplate 站点模板名称
 * @returns 返回包含状态和消息的对象，status为true表示成功，false表示失败，msg包含详细信息
 */
export const updateWebComponent = (content: string, filename: string, siteTemplate: string): { status: boolean; msg: string } => {
  try {
    // 获取项目根目录
    const projectRoot = path.resolve(__dirname, '../../');

    // 确保文件名不包含路径分隔符
    if (filename.includes('/') || filename.includes('\\')) {
      return { status: false, msg: '文件名不能包含路径分隔符' };
    }

    // 添加.vue扩展名（如果没有的话）
    const finalFilename = filename.endsWith('.vue') ? filename : `${filename}.vue`;

    // 构建目标文件路径
    const targetFilePath = path.join(projectRoot, 'web', 'app', 'templates', siteTemplate, finalFilename);

    // 检查文件是否存在
    if (!fs.existsSync(targetFilePath)) {
      return { status: false, msg: '组件文件不存在，无法更新' };
    }

    // 更新文件内容
    fs.writeFileSync(targetFilePath, content, 'utf8');

    console.log('组件文件更新成功:', targetFilePath);
    return { status: true, msg: '组件文件更新成功' };

  } catch (error) {
    console.error('更新组件失败:', error);
    return { status: false, msg: '更新组件失败: ' + error.message };
  }
}

/**
 * 更新Web页面文件内容
 * @param filePath 文件路径（来源：用户传入的路径参数）
 * @param content 文件内容（来源：用户传入的内容）
 * @returns 返回包含状态和消息的对象，status为true表示成功，false表示失败，msg包含详细信息
 */
export const updateWebPage = (filePath: string, content: string): { status: boolean; msg: string } => {
  try {
    // 获取项目根目录
    const projectRoot = path.resolve(__dirname, '../../');

    // 构建完整的文件路径
    const fullPath = path.join(projectRoot, filePath);

    // 确保目录存在
    const targetDir = path.dirname(fullPath);
    if (!fs.existsSync(targetDir)) {
      fs.mkdirSync(targetDir, { recursive: true });
    }

    // 写入文件内容（覆盖原有内容）
    fs.writeFileSync(fullPath, content, 'utf8');

    console.log('文件更新成功:', fullPath);
    return { status: true, msg: '文件更新成功' };

  } catch (error) {
    console.error('更新文件失败:', error);
    return { status: false, msg: '更新文件失败: ' + error.message };
  }
}


export const pageTemplate = `
<template>
  <div class="page-wraper">
    <!-- 使用Suspense包装异步组件，支持SSR -->
    <Suspense>
      <template #default>
        <Component :is="AshanComponent" :page-type="pageType" :base-page-code="basePageCode" />
      </template>
      <template #fallback>
        <div class="loading">
          <p>正在加载组件...</p>
        </div>
      </template>
    </Suspense>
  </div>
</template>

<script setup lang="ts">
import { defineAsyncComponent, type AsyncComponentLoader } from "vue";
const appConfig = useAppConfig();
const { siteInfo } = appConfig.systemConfig;
const pageType = "$pageType"; // 页面类型，判断是数据是预览还是正式 list page detail
const basePageCode = "$pageCode"; // 基础页面code
const curComponent = "$component";

/**
 * 创建异步组件加载器
 * @param template 主题模板名称
 * @returns AsyncComponentLoader 异步组件加载器
 */
const createAsyncComponentLoader = (template: string): AsyncComponentLoader => {
  return () => {
    const modules = import.meta.glob("@/templates/**/*.vue");
    const modulePath = "/templates/" + template + "/" + curComponent;
    const moduleLoader = modules[modulePath];
    if (moduleLoader) {
      return moduleLoader();
    }
    return import("@/templates/empty.vue");
  };
};

/**
 * 根据模板创建异步组件
 * @param template 主题模板名称
 * @returns 异步组件实例
 */
const createAshanComponent = (template: string) => {
  return defineAsyncComponent({
    loader: createAsyncComponentLoader(template),
    delay: 200,
    timeout: 3000,
    errorComponent: {
      template: '<div class="error">加载失败</div>'
    },
    loadingComponent: {
      template: '<div class="loading"><p>正在加载...</p></div>'
    }
  });
};

// 响应式的异步组件
const AshanComponent = computed(() => {
  const template = siteInfo.siteTemplate || "default";
  return createAshanComponent(template);
});

// 预加载组件以提升性能
onMounted(() => {
  const template = siteInfo.siteTemplate || "default";
  createAsyncComponentLoader(template)();
});
</script>

<style scoped lang="scss"></style>

`